home *** CD-ROM | disk | FTP | other *** search
/ Aminet 40 / Aminet 40 (2000)(Schatztruhe)[!][Dec 2000].iso / Aminet / util / cdity / ModeProSrc.lha / Daemon / Unnamed1 / 40beta / MPPatch.c < prev    next >
C/C++ Source or Header  |  1996-06-12  |  21KB  |  913 lines
  1. #include "MP.h"
  2. #include <graphics/videocontrol.h>
  3.   
  4. void CatchDNode(ULONG list,UBYTE *Name);
  5. //void PrintTags(struct TagItem *tags);
  6. //UBYTE *FindTagSting(ULONG ID);
  7. void CloneTextAttr(struct TTextAttr *Source, struct TTextAttr *Dest);
  8.  
  9. extern struct MPSem MPSem;
  10. extern CxObj  *Broker;
  11. extern struct MsgPort *BrokerPort;
  12. extern STRPTR MiscText[];
  13. extern BOOL V39;
  14. extern BYTE PublicSignal;
  15. extern struct Process  *MPTask;
  16. extern UWORD NumDriPens;
  17. extern defaultpens[];
  18. extern struct MsgPort *CatchPort;
  19. extern struct Screen ASM *(*OldOpenScreen)(REG __a0 struct NewScreen *,REG __a6 struct IntuitionBase *);
  20. extern struct Screen ASM *(*OldOpenScreenTagList)(REG __a0 struct ExtNewScreen *ns,
  21.                                              REG __a1 struct TagItem *taglist,
  22.                                              REG __a6 struct IntuitionBase * );
  23. extern BOOL ASM (*OldCloseScreen)(REG __a0 struct Screen *,REG __a6 struct IntuitionBase *);
  24. extern struct Window ASM *(*OldOpenWindow)(REG __a0 struct NewWindow *nw,
  25.                                              REG __a6 struct IntuitionBase *lib);
  26. extern struct Window ASM *(*OldOpenWindowTagList)(REG __a0 struct NewWindow *nw,
  27.                                                     REG __a1 struct TagItem *tags,
  28.                                                     REG __a6 struct IntuitionBase *lib);
  29. extern BOOL ASM *(*OldLayoutMenusA)(REG __a0 struct Menu *fm,
  30.                                       REG __a1 APTR vi, 
  31.                                       REG __a2 struct TagItem *tags,
  32.                                       REG __a6 struct Library *lib);
  33.  
  34. struct Screen ASM __saveds  *NewOpenScreen(REG __a0 struct ExtNewScreen *ns)
  35. {
  36.   return(NewOpenScreenTagList(ns,NULL));
  37. }
  38.  
  39. struct DimensionInfo diminfo;
  40. struct DisplayInfo   dispinfo;
  41.  
  42. UBYTE *Topaz="topaz.font";
  43.  
  44. struct Screen *scr;
  45. struct TextFont *textfont;
  46. struct ScreenModeRequester *sr;
  47.  
  48. WORD   width,
  49.        height,
  50.        depth;
  51. BOOL   dodepth;
  52.  
  53. LONG   autoscroll,
  54.        look3d,
  55.        modeid,
  56.        overscan,
  57.        interleave,
  58.        wbscr;
  59.        //likewb;
  60. BOOL   changed,modechanged;
  61.        
  62. WORD   pens[]={~0},
  63.        *screenpens;
  64.        
  65. struct Task *task;
  66. struct DefaultNode *n;
  67. struct TagItem ti[21],
  68.               *tag;
  69. struct TagItem fonttags[]=
  70. {
  71.   TA_DeviceDPI,(1<<16) | 1,TAG_DONE,0
  72. };
  73.  
  74.  
  75. ULONG  l,ehbham;
  76.  
  77. struct TextAttr *storedfont;
  78.  
  79. UBYTE  cliname[41],*taskname;
  80. UBYTE *title;
  81.        
  82. struct OpenNode *ON;
  83.  
  84. LONG custombm;
  85.    
  86.       
  87. struct Screen ASM __saveds  *NewOpenScreenTagList(REG __a0 struct ExtNewScreen *ns,
  88.                                                   REG __a1 struct TagItem *taglist)
  89. {
  90.   ObtainSemaphoreShared(&MPSem.ListSem); 
  91.   ObtainSemaphore(&MPSem.NodeSem); 
  92.   /* Now that we've got the semaphore all globals are mine */
  93.   /* initialize everything */
  94.  
  95.   title=NULL;
  96.  
  97.   ON=NULL;   //likewb=0;
  98.   
  99.   custombm=changed=modechanged=depth=look3d=overscan=interleave=0L;
  100.   dodepth=FALSE;
  101.   
  102.   wbscr=0;  
  103.   
  104.   width=height=autoscroll=modeid=-1;
  105.  
  106.   screenpens=pens;
  107.   
  108.   task=FindTask(0);
  109.   taskname=task->tc_Node.ln_Name;
  110.  
  111.   if(GetProgramName(cliname,40)) /* Get cli program's name */
  112.     if(cliname[0]!=0)            /* make sure cliname contains something */
  113.       taskname=cliname;
  114.   
  115.   /* Initialization Done */
  116.  
  117.  
  118.  
  119.   /**** Extract screen info from ns and taglist ****/  
  120.   if(ns)                     
  121.   {
  122.     storedfont=ns->Font;
  123.     width    =ns->Width;
  124.     height   =ns->Height;
  125.     modeid   =ns->ViewModes;
  126.     depth    =ns->Depth;
  127.     title    =ns->DefaultTitle;
  128.     custombm =ns->Type & CUSTOMBITMAP;
  129.     if(ns->Type & NS_EXTENDED)
  130.       taglist=ns->Extension;
  131.   }
  132.   if(taglist)
  133.   {
  134.     //likewb=(ULONG)FindTagItem(SA_LikeWorkbench,taglist);
  135.     //printf("\n---------\n");
  136.     //PrintTags(taglist);
  137.     custombm  =GetTagData(SA_BitMap,    custombm,taglist);
  138.     width     =GetTagData(SA_Width,     width,   taglist);
  139.     height    =GetTagData(SA_Height,    height,  taglist);
  140.     autoscroll=GetTagData(SA_AutoScroll,autoscroll,taglist);
  141.     overscan  =GetTagData(SA_Overscan,  overscan,taglist);
  142.     modeid    =GetTagData(SA_DisplayID, modeid,  taglist);
  143.     depth     =GetTagData(SA_Depth,     depth,   taglist);
  144.     title     =(UBYTE *)GetTagData(SA_Title,(ULONG)title,taglist);
  145.     wbscr     =(GetTagData(SA_Type,0,taglist) & 15) == WBENCHSCREEN;
  146.     interleave=GetTagData(SA_Interleaved,interleave,taglist);
  147.     if(tag=FindTagItem(SA_Overscan,taglist))
  148.       if(!FindTagItem(SA_DClip,taglist))
  149.         overscan=tag->ti_Data;
  150.     if(tag=FindTagItem(SA_Pens,taglist))
  151.     {
  152.       screenpens=(UWORD *)(tag->ti_Data);
  153.       //look3d=TRUE;
  154.     }
  155.     //printf("TagList w=%4d h=%4d id=%8x d=%4d t=%s\n",width,height,modeid,depth,title);
  156.   }
  157.   n=NULL;
  158.  
  159. //  printf("\nOld Tags:\n");  
  160. //  PrintTags(taglist);
  161.  
  162.   
  163.   if(!title) title=GetString(MSG_ITEM_NO_NAME); /* Just in case ther isn't a title */
  164.  
  165.   if(!(n=FindDNode(&MPSem.PromotionList[1],title)))
  166.     if(!(n=FindDNode(&MPSem.PromotionList[0],taskname)))
  167.     { 
  168.       if(MPSem.CatchPrograms && taskname)   //Catch new names only.
  169.         CatchDNode(0,taskname);
  170.       if(MPSem.CatchScreens) CatchDNode(1,title);
  171.     }
  172.  
  173.   if(!MPSem.Enabled || !n || wbscr)
  174.   {
  175.     scr=OldOpenScreenTagList(ns,taglist,IntuitionBase);
  176.     ReleaseSemaphore(&MPSem.ListSem);
  177.     ReleaseSemaphore(&MPSem.NodeSem);
  178.     return(scr);
  179.   }
  180.   
  181.   ehbham=modeid & (HAM_KEY | EXTRAHALFBRITE_KEY); 
  182.   
  183.   if(n)
  184.   {
  185.     look3d     =n->Look3D;
  186.     interleave =(n->Flags & INTERLEAVE) | interleave;
  187.     screenpens =n->Pens;
  188.  
  189.     switch(n->ModeSelect)
  190.     {
  191.       case 1:
  192.         if(modeid > -1)
  193.         {
  194.           modeid      =(n->ModeID & MONITOR_ID_MASK) | (modeid & (~MONITOR_ID_MASK));
  195.           modechanged=TRUE;
  196.         }
  197.       case 0:          
  198.         autoscroll  =n->AutoScroll;
  199.         break;
  200.       case 2:
  201.         modeid      =n->ModeID | ehbham;
  202.         overscan    =n->OverscanType;
  203.         width       =n->Width;
  204.         height      =n->Height;
  205.         autoscroll  =n->AutoScroll;
  206.         if(n->Flags & DEPTH)
  207.         {
  208.           depth=n->Depth;
  209.           dodepth=TRUE;
  210.         }
  211.         changed=TRUE;
  212.         break;
  213.       case 3:
  214.         if((sr=(struct ScreenModeRequester *)AllocAslRequestTags(ASL_ScreenModeRequest,
  215.                     ASLSM_TitleText             ,title,
  216.                     ASLSM_DoWidth               ,TRUE ,
  217.                     ASLSM_DoHeight              ,TRUE ,
  218.                     ASLSM_DoOverscanType        ,TRUE ,
  219.                     ASLSM_DoAutoScroll          ,TRUE ,
  220.                     ASLSM_DoDepth               ,n->Flags & DEPTH,
  221.                     ASLSM_InitialAutoScroll     ,n->AutoScroll,
  222.                     ASLSM_InitialDisplayWidth   ,n->Width,
  223.                     ASLSM_InitialDisplayHeight  ,n->Height,
  224.                     ASLSM_InitialDisplayID      ,n->ModeID,
  225.                     ASLSM_InitialDisplayDepth   ,n->Depth,
  226.                     ASLSM_NegativeText          ,GetString(MSG_REQ_USE_DEFAULT),
  227.                     ASLSM_PropertyFlags         ,0,
  228.                     ASLSM_PropertyMask          ,BADMODES,                      
  229.                     TAG_END 
  230.                     )))
  231.         {
  232.           if(AslRequest(sr,NULL))
  233.           {
  234.             modeid    =sr->sm_DisplayID | ehbham;
  235.             overscan  =sr->sm_OverscanType;
  236.             width     =sr->sm_DisplayWidth;
  237.             height    =sr->sm_DisplayHeight;    
  238.             changed=TRUE;
  239.             if(n->Flags & DEPTH)
  240.             {
  241.               depth=sr->sm_DisplayDepth;
  242.               dodepth=TRUE;
  243.             }
  244.           }
  245.           FreeAslRequest(sr);  
  246.         }
  247.         break; 
  248.     }/* end switch*/
  249.   }/* end if */
  250.   
  251.   /**** Setup promoted taglist ****/
  252.  
  253.   l=0;
  254.   if(changed && !(custombm))
  255.   {
  256.     ti[l].ti_Tag=SA_Width;
  257.     ti[l].ti_Data=width;
  258.     l++;
  259.     ti[l].ti_Tag=SA_Height;
  260.     ti[l].ti_Data=height;
  261.     l++;
  262.     ti[l].ti_Tag=SA_Overscan;
  263.     ti[l].ti_Data=overscan;
  264.     l++;
  265.   }
  266.   if(modechanged || changed)
  267.   {
  268.     ti[l].ti_Tag=SA_DisplayID;
  269.     ti[l].ti_Data=modeid;
  270.     l++;
  271.   }
  272.   if(look3d)
  273.   {
  274.     ti[l].ti_Tag=SA_Pens;
  275.     ti[l].ti_Data=(ULONG)screenpens;
  276.     l++;
  277.     
  278.     if(depth==1)
  279.     {
  280.       depth=2;
  281.       dodepth=TRUE;
  282.       //  ti[l].ti_Tag=SA_Depth;
  283.       //  ti[l].ti_Data=2;
  284.       //   l++;
  285.     }
  286.   }
  287.   if(autoscroll)
  288.   {
  289.     ti[l].ti_Tag=SA_AutoScroll;
  290.     ti[l].ti_Data=TRUE;
  291.     l++;
  292.   }
  293.  
  294.   
  295.   if(n->Flags & CENTER)
  296.   {    
  297.     if(GetDisplayInfoData(NULL,(UBYTE *)&diminfo,sizeof(struct DimensionInfo),DTAG_DIMS,modeid))
  298.     {
  299.       if(width>-1)
  300.       {
  301.         ti[l].ti_Tag=SA_Left;
  302.         ti[l].ti_Data=((diminfo.Nominal.MaxX-diminfo.Nominal.MinX)-width)/2;
  303.         l++;
  304.       }
  305.       if(height>-1)
  306.       {
  307.         ti[l].ti_Tag=SA_Top;
  308.         ti[l].ti_Data=((diminfo.Nominal.MaxY-diminfo.Nominal.MinY)-height)/2;
  309.         l++;
  310.       }
  311.     }
  312.   }
  313.   
  314.  
  315.   switch(n->FontType)
  316.   {
  317.     case SFONT_SYS:
  318.       if(ns) ns->Font=0;
  319.       ti[l].ti_Tag=SA_SysFont;
  320.       ti[l].ti_Data=1;
  321.       l++;
  322.       break;
  323.     case SFONT_MP:
  324.       if(n->Font.tta_Name)
  325.       {
  326.         if(ON=AllocMem(sizeof(struct OpenNode),MEMF_CLEAR|MEMF_PUBLIC))
  327.         {
  328.           ON->Flags|=ON_FONT;
  329.         
  330.           ti[l].ti_Tag  =SA_Font;
  331.           ti[l].ti_Data =(ULONG)&ON->TA;
  332.         
  333.           l++;
  334.  
  335.           if(n->Flags & FIXASPECT && modeid != -1)
  336.           {
  337.             if(GetDisplayInfoData(NULL,(UBYTE *)&dispinfo,sizeof(struct DisplayInfo),DTAG_DISP,modeid))
  338.             {
  339.               fonttags[0].ti_Data=(ULONG)dispinfo.Resolution.x|(((ULONG)dispinfo.Resolution.y)<<16);
  340.               n->Font.tta_Style |= FSF_TAGGED;
  341.               n->Font.tta_Tags   =fonttags;
  342.             }
  343.           }
  344.           CloneTextAttr(&n->Font,&ON->TA);
  345.  
  346.           n->Font.tta_Style &= (~FSF_TAGGED);
  347.           n->Font.tta_Tags=NULL;
  348.         }
  349.       }
  350.       break;
  351.   }
  352.  
  353.   if(n->PubOptions==1)
  354.   {
  355.     ULONG error=FALSE;
  356.     struct TagItem badtags[]=
  357.     {
  358.       SA_BitMap,    1<<0,
  359. //      SA_PubName,   1<<1,
  360.       SA_PubSig,    1<<2,
  361.       SA_PubTask,   1<<3,
  362.       SA_BackFill,  1<<4,
  363.       TAG_DONE,     0
  364.     };
  365.     
  366.     if(taglist) error =PackBoolTags(0,taglist,badtags);
  367.     if(ns)      error|=(ns->Type & CUSTOMBITMAP);
  368.     
  369.     if(error==0)
  370.     {
  371.       if(!ON) ON=AllocMem(sizeof(struct OpenNode),MEMF_CLEAR|MEMF_PUBLIC);
  372.       if(ON)
  373.       {
  374.         struct OpenNode *won;
  375.         UBYTE number[8];
  376.         ULONG cnt=1,len;
  377.         
  378.         strncpy(ON->PubName,n->PubName,MAXPUBSCREENNAME);
  379.         ON->PubName[MAXPUBSCREENNAME]=0;
  380.         len=strlen(ON->PubName);
  381.         len=min(len,MAXPUBSCREENNAME-9);
  382.         
  383.         won=(struct OpenNode *)MPSem.OpenList.lh_Head;
  384.         while(won->on_Node.ln_Succ)
  385.         {
  386.           if(cnt > 1)   
  387.           {
  388.             number[0]='.';
  389.             stci_d(&number[1],cnt);        
  390.             ON->PubName[len]=0;
  391.             strncat(ON->PubName,number,MAXPUBSCREENNAME);
  392.             ON->PubName[MAXPUBSCREENNAME]=0;
  393.           }
  394.           
  395.           if(0==strcmp(ON->PubName,won->PubName))
  396.           {
  397.             won=(struct OpenNode *)MPSem.OpenList.lh_Head;
  398.             cnt++;
  399.           }
  400.           else
  401.             won=(struct OpenNode *)won->on_Node.ln_Succ;
  402.         }
  403.         
  404.         ON->PubName[MAXPUBSCREENNAME]=0;
  405.         ON->Flags|=ON_PUBLIC|ON_OPEN;
  406.         
  407.         ti[l].ti_Tag=SA_Title;
  408.         ti[l].ti_Data=(ULONG)ON->PubName;
  409.         l++;
  410.  
  411.         ti[l].ti_Tag=SA_PubName;
  412.         ti[l].ti_Data=(ULONG)ON->PubName;
  413.         l++;
  414.     
  415.         ti[l].ti_Tag=SA_PubSig;
  416.         ti[l].ti_Data=PublicSignal;
  417.         l++;
  418.         
  419.         ti[l].ti_Tag=SA_PubTask;
  420.         ti[l].ti_Data=(ULONG)MPTask;
  421.         l++;
  422.         
  423.         
  424.         if(!(ON->Flags & ON_FONT))
  425.         {
  426.           struct TTextAttr *ot=NULL;
  427.           
  428.           if(ns)  ot=(struct TTextAttr *)ns->Font;          
  429.           ot=(struct TTextAttr *)GetTagData(SA_Font,(ULONG)ot,taglist);
  430.           
  431.           if(ot)
  432.           {
  433.             ON->Flags|=ON_FONT;
  434.  
  435.             CloneTextAttr(ot,&ON->TA);
  436.  
  437.             ti[l].ti_Tag =SA_Font;
  438.             ti[l].ti_Data=(ULONG)&ON->TA;
  439.             l++;
  440.           }
  441.         }
  442.       }
  443.     }
  444.   }
  445.  
  446.   if(n->Flags & SCRHOTKEY)
  447.   {
  448.     if(!ON) ON=AllocMem(sizeof(struct OpenNode),MEMF_CLEAR|MEMF_PUBLIC);
  449.       if(ON)
  450.       {
  451.         if(ON->HotKey=AllocVec(strlen(n->HotKey)+1,MEMF_CLEAR|MEMF_PUBLIC))
  452.         {
  453.           strcpy(ON->HotKey,n->HotKey);
  454.           ON->Cx=AddHotKey(Broker,BrokerPort,ON->HotKey,(ULONG)ON);
  455.         }
  456.       }
  457.   }
  458.   
  459.   if(n->Flags & SHAREPENS)
  460.   {
  461.     ti[l].ti_Tag=SA_SharePens;
  462.     ti[l].ti_Data=TRUE;
  463.     l++;
  464.   }
  465.  
  466.   if(dodepth && !(custombm) && !(ehbham))
  467.   {
  468.     ti[l].ti_Tag=SA_Depth;
  469.     ti[l].ti_Data=depth;
  470.     l++;
  471.   }
  472.  
  473.   if(interleave && !(custombm))
  474.   {
  475.     ti[l].ti_Tag=SA_Interleaved;
  476.     ti[l].ti_Data=TRUE;
  477.     l++;
  478.   }
  479.  
  480.   
  481.   ti[l].ti_Tag=SA_MinimizeISG; /*** just a little extra for v40 ***/
  482.   ti[l].ti_Data=TRUE;
  483.   l++;
  484.  
  485.   if(taglist)
  486.   {
  487.     ti[l].ti_Tag=TAG_MORE;
  488.     ti[l].ti_Data=(ULONG)taglist;
  489.   }
  490.   else
  491.   {
  492.     ti[l].ti_Tag=TAG_DONE;
  493.     ti[l].ti_Data=0;
  494.   }
  495.   /**** End Setup taglist ****/
  496.  
  497. //  printf("\nNew Tags:\n");  
  498. //  PrintTags(ti);
  499.  
  500.   
  501.   if(ON)
  502.   {
  503.     if(ON->Flags & ON_FONT)
  504.       textfont=OpenDiskFont((struct TextAttr *)&ON->TA);
  505.   }
  506.   
  507.   scr=OldOpenScreenTagList(ns,ti,IntuitionBase);
  508.  
  509.   if(scr && n->Flags & SHAREPENS && n->LockedPens && V39)
  510.   {
  511.     UBYTE *str,state=0,done=FALSE;
  512.     WORD num=0,num1=0,num2;
  513.     struct ColorMap *cm;
  514.     
  515.     cm=scr->ViewPort.ColorMap;
  516.     
  517.     str=n->LockedPens;
  518.     
  519.     while(!done)
  520.     {
  521.       if(!*str) done=TRUE;
  522.       
  523.       if(*str>='0' && *str<='9')
  524.       {
  525.         if(state==0)
  526.           state=1;
  527.         num=0;
  528.         while(*str>='0' && *str<='9')
  529.         {
  530.           num*=10;
  531.           num+=*str - '0';
  532.           str++;
  533.         }
  534.         
  535.         switch(state)
  536.         {
  537.           case 1:
  538.        //     printf("obtaining %d\n",num);
  539.             ObtainPen(cm,num,0,0,0, PEN_EXCLUSIVE | PEN_NO_SETCOLOR);
  540.             break;
  541.           case 2:
  542.             for(num2=num1+1;num2<=num;num2++)
  543.             {
  544.          //     printf("obtaining %d\n",num2);
  545.               ObtainPen(cm,num2,0,0,0, PEN_EXCLUSIVE | PEN_NO_SETCOLOR);
  546.             }
  547.             break;
  548.         }
  549.         state=0;
  550.        
  551.       }
  552.       
  553.       if(*str==' ')
  554.         for(;*str==' ';str++);
  555.       else
  556.         if(*str=='-')
  557.         {
  558.           num1=num;
  559.           state=2;
  560.           str++;
  561.         }
  562.         else
  563.           str++;
  564.     }
  565.   }
  566.  
  567.  
  568.  
  569.   if(ON)
  570.   {
  571.     if(ON->Flags & ON_FONT)
  572.       if(textfont)
  573.         CloseFont(textfont);
  574.     
  575.     if(scr)
  576.     {
  577.       ON->Screen=scr;
  578.       if(ON->Flags & ON_PUBLIC)
  579.       {
  580.         if(n->PubOptions == 1)
  581.         {
  582.           PubScreenStatus(scr,0);
  583.         }
  584.       }
  585.       AddHead(&MPSem.OpenList,(struct Node *)ON);
  586.     }
  587.     else
  588.       FreeOpenNode(ON);
  589.   }
  590.   
  591. /*
  592.   if(scr)
  593.   {
  594.     VideoControlTags(scr->ViewPort.ColorMap,
  595.                       VTAG_BORDERSPRITE_SET,TRUE,
  596.                       TAG_DONE);
  597.   }
  598. */
  599.   if(ns) ns->Font=storedfont;
  600.  
  601.   if(!scr) scr=OldOpenScreenTagList((struct ExtNewScreen *)ns,taglist,IntuitionBase);
  602.  
  603.   ReleaseSemaphore(&MPSem.ListSem);
  604.   ReleaseSemaphore(&MPSem.NodeSem);
  605.   return(scr);
  606. }
  607.  
  608. BOOL __saveds ASM NewCloseScreen(REG __a0 struct Screen *S)
  609. {
  610.   struct OpenNode *on;
  611.   BOOL rv,ok=FALSE;
  612.   ULONG pub=0;
  613.  
  614.  
  615.   ObtainSemaphore(&MPSem.OpenListSem);
  616.   
  617.   on=(struct OpenNode *)MPSem.OpenList.lh_Head;
  618.   while(on->on_Node.ln_Succ)
  619.   {
  620.     if(on->Screen==S)
  621.     {
  622.       Remove((struct Node *)on);
  623.       pub=on->Flags & ON_PUBLIC;
  624.       ok=TRUE;
  625.       break;
  626.     }
  627.     on=(struct OpenNode *)on->on_Node.ln_Succ;
  628.   }
  629.   
  630.   if(!ok) on=NULL;
  631.   
  632.   if(!pub)
  633.   {
  634.     if(rv=OldCloseScreen(S,IntuitionBase))
  635.       FreeOpenNode(on);
  636.     else
  637.       if(on)
  638.         AddHead(&MPSem.OpenList,(struct Node *)on);  
  639.   }
  640.   else  // Public
  641.   {
  642.     on->Flags&=(~ON_OPEN);
  643.     S->DefaultTitle=S->Title=on->PubName;
  644.     ShowTitle(S,TRUE);
  645.     AddHead(&MPSem.OpenList,(struct Node *)on);
  646.     rv=TRUE;
  647.     Signal((struct Task *)MPTask,1<<PublicSignal);
  648.   }          
  649.   ReleaseSemaphore(&MPSem.OpenListSem);   
  650.  
  651.   return(rv);
  652. }
  653.      
  654. void FreeOpenNode(struct OpenNode *on)
  655. {
  656.   if(on) 
  657.   { 
  658.     //if(on->TA.tta_Name)
  659.     FreeVec(on->TA.tta_Name);
  660.     //if(on->TA.tta_Tags)
  661.     FreeVec(on->TA.tta_Tags);
  662.     //if(on->Cx)
  663.     DeleteCxObjAll(on->Cx);
  664.     FreeVec(on->HotKey);
  665.     FreeMem(on,sizeof(struct OpenNode));
  666.   }
  667. }
  668.  
  669. struct Window __saveds ASM *NewOpenWindow(REG __a0 struct NewWindow *nw)
  670. {
  671.   return(NewOpenWindowTagList(nw,NULL));
  672. }
  673.  
  674. struct Window __saveds ASM *NewOpenWindowTagList(REG __a0 struct NewWindow *nw,
  675.                                                    REG __a1 struct TagItem *tags)
  676. {
  677.   struct Window *w;
  678.   struct TagItem ti[]={WA_NewLookMenus , TRUE , 
  679.                        TAG_DONE , 0};
  680.  
  681. //  ObtainSemaphoreShared(&MPSem.ListSem);
  682.  
  683.   if(MPSem.EnabledNLM)  
  684.   {
  685.     if(tags)
  686.     {
  687.       ti[1].ti_Tag =TAG_MORE;
  688.       ti[1].ti_Data=(ULONG)tags;
  689.     }              
  690.     w=(struct Window *)OldOpenWindowTagList(nw,ti,IntuitionBase);
  691.   }
  692.   else
  693.     w=(struct Window *)OldOpenWindowTagList(nw,tags,IntuitionBase);
  694.  
  695. //  ReleaseSemaphore(&MPSem.ListSem);
  696.   
  697.   return(w); 
  698. }
  699.  
  700. BOOL __saveds ASM NewLayoutMenusA(REG __a0 struct Menu *fm,
  701.                                   REG __a1 APTR vi, 
  702.                                   REG __a2 struct TagItem *tags)
  703. {
  704.   BOOL rv;
  705.   struct TagItem ti[2]=
  706.   {
  707.     GTMN_NewLookMenus,TRUE,
  708.     TAG_DONE,0
  709.   };
  710.  
  711. //  ObtainSemaphoreShared(&MPSem.ListSem);
  712.  
  713.   if(MPSem.EnabledNLM)    
  714.   {
  715.     if(tags)
  716.     {
  717.       ti[1].ti_Tag=TAG_MORE;
  718.       ti[1].ti_Data=(ULONG)tags;
  719.     }
  720.     rv=(BOOL)OldLayoutMenusA(fm,vi,ti,GadToolsBase);
  721.   }
  722.   else
  723.     rv=(BOOL)OldLayoutMenusA(fm,vi,tags,GadToolsBase);
  724.   
  725. //  ReleaseSemaphore(&MPSem.ListSem);
  726.   return(rv); 
  727. }
  728.  
  729. void CatchDNode(ULONG dest, UBYTE *Name)
  730. {
  731.   struct DefaultNode *dnode;
  732.   LONG l;
  733.   
  734.   if(dnode=AllocVec(sizeof(struct DefaultNode),MEMF_CLEAR|MEMF_PUBLIC))
  735.   {
  736.     if(dnode->Def_Node.ln_Name=AllocVec(strlen(Name)+1,MEMF_CLEAR|MEMF_PUBLIC))
  737.     {
  738.       strcpy(dnode->Def_Node.ln_Name,Name);
  739.       dnode->Type         =dest;
  740.       dnode->Width        =width;
  741.       dnode->Height       =height;
  742.       dnode->AutoScroll   =autoscroll;
  743.       dnode->ModeSelect   =0;
  744.       dnode->ModeID       =modeid;
  745.       dnode->OverscanType =overscan;
  746.       dnode->Look3D       =look3d;
  747.       dnode->Flags        =0;
  748.       dnode->Depth        =depth;
  749.       if(interleave)
  750.         dnode->Flags|=INTERLEAVE;
  751.       l=0;
  752.  
  753.       if(screenpens)
  754.         for(;l<NumDriPens && screenpens[l]!=(~0);l++)
  755.           dnode->Pens[l]=screenpens[l]; 
  756.  
  757.       for(;l<NumDriPens;l++)
  758.         dnode->Pens[l]=defaultpens[l];
  759.  
  760.       PutMsg(CatchPort,(struct Message *)dnode);
  761.       return;
  762.     }
  763.     FreeVec(dnode);
  764.   }
  765. }
  766.  
  767. /*
  768.  
  769. void PrintTags(struct TagItem *tags)
  770. {
  771.   struct TagItem *ti;
  772.   
  773.   while(ti=NextTagItem(&tags))
  774.   {
  775.     printf("%s  %10u\n",FindTagSting(ti->ti_Tag),ti->ti_Data);
  776.   }
  777. }
  778.  
  779.  
  780. ULONG TagID[]=
  781. {
  782.   SA_Left,
  783.   SA_Top,
  784.   SA_Width,
  785.   SA_Height,
  786.   SA_Depth,
  787.   SA_DetailPen,
  788.   SA_BlockPen,
  789.   SA_Title,
  790.   SA_Colors,
  791.   SA_ErrorCode,
  792.   SA_Font,
  793.   SA_SysFont,
  794.   SA_Type,
  795.   SA_BitMap,
  796.   SA_PubName,
  797.   SA_PubSig,
  798.   SA_PubTask,
  799.   SA_DisplayID,
  800.   SA_DClip,
  801.   SA_Overscan,
  802.   SA_Obsolete1,
  803.   SA_ShowTitle,
  804.   SA_Behind,
  805.   SA_Quiet,
  806.   SA_AutoScroll,
  807.   SA_Pens,
  808.   SA_FullPalette,
  809.   SA_ColorMapEntries,
  810.   SA_Parent,
  811.   SA_Draggable,
  812.   SA_Exclusive,
  813.   SA_SharePens,
  814.   SA_BackFill,
  815.   SA_Interleaved,
  816.   SA_Colors32,
  817.   SA_VideoControl,
  818.   SA_FrontChild,
  819.   SA_BackChild,
  820.   SA_LikeWorkbench,
  821.   SA_Reserved,
  822.   SA_MinimizeISG,
  823.   0xffffffff,
  824. };
  825.  
  826. UBYTE *TagStrings[]=
  827. {
  828.   "SA_Left",
  829.   "SA_Top",
  830.   "SA_Width",
  831.   "SA_Height",
  832.   "SA_Depth",
  833.   "SA_DetailPen",
  834.   "SA_BlockPen",
  835.   "SA_Title",
  836.   "SA_Colors",
  837.   "SA_ErrorCode",
  838.   "SA_Font",
  839.   "SA_SysFont",
  840.   "SA_Type",
  841.   "SA_BitMap",
  842.   "SA_PubName",
  843.   "SA_PubSig",
  844.   "SA_PubTask",
  845.   "SA_DisplayID",
  846.   "SA_DClip",
  847.   "SA_Overscan",
  848.   "SA_Obsolete1",
  849.   "SA_ShowTitle",
  850.   "SA_Behind",
  851.   "SA_Quiet",
  852.   "SA_AutoScroll",
  853.   "SA_Pens",
  854.   "SA_FullPalette",
  855.   "SA_ColorMapEntries",
  856.   "SA_Parent",
  857.   "SA_Draggable",
  858.   "SA_Exclusive",
  859.   "SA_SharePens",
  860.   "SA_BackFill",
  861.   "SA_Interleaved",
  862.   "SA_Colors32",
  863.   "SA_VideoControl",
  864.   "SA_FrontChild",
  865.   "SA_BackChild",
  866.   "SA_LikeWorkbench",
  867.   "SA_Reserved",
  868.   "SA_MinimizeISG",
  869.   "Unknown Tag"
  870. };
  871.  
  872.  
  873.  
  874.  
  875.  
  876. UBYTE *FindTagSting(ULONG id)
  877. {
  878.   ULONG l;
  879.   
  880.   for(l=0;;l++)
  881.   {
  882.     if(TagID[l]==id || TagID[l]==0xffffffff)
  883.       return(TagStrings[l]);
  884.   }
  885.   return(TagStrings[l]);
  886. }
  887.  
  888. */
  889.  
  890.  
  891. void CloneTextAttr(struct TTextAttr *Source, struct TTextAttr *Dest)
  892. {
  893.   CopyMem(Source,Dest,sizeof(struct TextAttr));
  894.     
  895.   if(Dest->tta_Name=AllocVec(strlen(Source->tta_Name)+1,MEMF_CLEAR|MEMF_PUBLIC))
  896.   {
  897.     strcpy(Dest->tta_Name,Source->tta_Name);
  898.     if(Dest->tta_Style & FSF_TAGGED)
  899.     {
  900.       if(!(Dest->tta_Tags=CloneTagItems(Source->tta_Tags)))
  901.         Dest->tta_Style &= (~FSF_TAGGED);
  902.     }
  903.   }
  904.   else
  905.   {
  906.     Dest->tta_Name=Topaz;
  907.     Dest->tta_YSize=8;
  908.     Dest->tta_Style=0;
  909.     Dest->tta_Flags=0;
  910.   }
  911. }
  912.  
  913.